Termination of the following Term Rewriting System could not be shown:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
U62: {1}
U63: {1}
U71: {1}
s: {1}
length: {1}
U81: {1}
nil: empty set
U91: {1}
take: {1, 2}
and: {1}
isNatIListKind: empty set
isNatKind: empty set


CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
U62: {1}
U63: {1}
U71: {1}
s: {1}
length: {1}
U81: {1}
nil: empty set
U91: {1}
take: {1, 2}
and: {1}
isNatIListKind: empty set
isNatKind: empty set

Using Improved CS-DPs we result in the following initial Q-CSDP problem.

↳ CSR
  ↳ CSDependencyPairsProof
QCSDP
      ↳ QCSDependencyGraphProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, U121, U221, U321, U431, U531, U631, LENGTH, U811, TAKE} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U111, U211, U311, U421, U411, U521, U511, U621, U611, U711, AND, U911} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, ISNAT, ISNATILIST, ISNATILISTKIND, ISNATKIND, U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DPo are:

U111(tt, V1) → U121(isNatList(V1))
U111(tt, V1) → ISNATLIST(V1)
U211(tt, V1) → U221(isNat(V1))
U211(tt, V1) → ISNAT(V1)
U311(tt, V) → U321(isNatList(V))
U311(tt, V) → ISNATLIST(V)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U411(tt, V1, V2) → ISNAT(V1)
U421(tt, V2) → U431(isNatIList(V2))
U421(tt, V2) → ISNATILIST(V2)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U511(tt, V1, V2) → ISNAT(V1)
U521(tt, V2) → U531(isNatList(V2))
U521(tt, V2) → ISNATLIST(V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U611(tt, V1, V2) → ISNAT(V1)
U621(tt, V2) → U631(isNatIList(V2))
U621(tt, V2) → ISNATILIST(V2)
U711(tt, L) → LENGTH(L)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
ISNAT(s(V1)) → ISNATKIND(V1)
ISNATILIST(V) → U311(isNatIListKind(V), V)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
LENGTH(cons(N, L)) → U711(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
LENGTH(cons(N, L)) → AND(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → AND(isNatList(L), isNatIListKind(L))
LENGTH(cons(N, L)) → ISNATLIST(L)
TAKE(0, IL) → U811(and(isNatIList(IL), isNatIListKind(IL)))
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)
TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
TAKE(s(M), cons(N, IL)) → AND(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
TAKE(s(M), cons(N, IL)) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(s(M), cons(N, IL)) → ISNATILIST(IL)

The collapsing dependency pairs are DPc:

U711(tt, L) → L
U911(tt, IL, M, N) → N
AND(tt, X) → X


The hidden terms of R are:

zeros
take(M, IL)
isNatIListKind(V2)

Every hiding context is built from:

take on positions {1, 2}
and on positions {1}

Hence, the new unhiding pairs DPu are :

U711(tt, L) → U(L)
U911(tt, IL, M, N) → U(N)
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(zeros) → ZEROS
U(take(M, IL)) → TAKE(M, IL)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 2 SCCs with 12 less nodes.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
QCSDP
            ↳ QCSDPReductionPairProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, TAKE} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U511, U521, AND, U311, U611, U621, U411, U421, U111, U211, U911} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, U, ISNATILIST, ISNATKIND, ISNATILISTKIND, ISNAT} are not replacing on any position.

The TRS P consists of the following rules:

ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U911(tt, IL, M, N) → U(N)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
TAKE(s(M), cons(N, IL)) → AND(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
TAKE(s(M), cons(N, IL)) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(s(M), cons(N, IL)) → ISNATILIST(IL)
U511(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = x2   
POL(ISNAT(x1)) = 0   
POL(ISNATILIST(x1)) = 0   
POL(ISNATILISTKIND(x1)) = 0   
POL(ISNATKIND(x1)) = 0   
POL(ISNATLIST(x1)) = 0   
POL(TAKE(x1, x2)) = x1 + x2   
POL(U(x1)) = x1   
POL(U11(x1, x2)) = x1   
POL(U111(x1, x2)) = 0   
POL(U12(x1)) = 0   
POL(U21(x1, x2)) = x1   
POL(U211(x1, x2)) = 0   
POL(U22(x1)) = 0   
POL(U31(x1, x2)) = x1 + x2   
POL(U311(x1, x2)) = 0   
POL(U32(x1)) = 0   
POL(U41(x1, x2, x3)) = x2   
POL(U411(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = x1   
POL(U421(x1, x2)) = 0   
POL(U43(x1)) = 0   
POL(U51(x1, x2, x3)) = 1 + 2·x1 + 2·x2   
POL(U511(x1, x2, x3)) = x1   
POL(U52(x1, x2)) = 1 + 2·x1   
POL(U521(x1, x2)) = 0   
POL(U53(x1)) = 1   
POL(U61(x1, x2, x3)) = 2 + 2·x1 + 2·x2 + x3   
POL(U611(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 1 + x1   
POL(U621(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 2   
POL(U81(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 2·x4   
POL(U911(x1, x2, x3, x4)) = x4   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1   
POL(isNat(x1)) = 0   
POL(isNatIList(x1)) = x1   
POL(isNatIListKind(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatList(x1)) = 2 + 2·x1   
POL(length(x1)) = 2 + x1   
POL(nil) = 0   
POL(s(x1)) = 1   
POL(take(x1, x2)) = x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

and(tt, X) → X
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
TAKE(s(M), cons(N, IL)) → AND(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
TAKE(s(M), cons(N, IL)) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(s(M), cons(N, IL)) → ISNATILIST(IL)

could be oriented strictly and thus removed.
The pairs

ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
U911(tt, IL, M, N) → U(N)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
U511(tt, V1, V2) → ISNAT(V1)

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
QCSDP
                ↳ QCSDependencyGraphProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, TAKE} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U511, U521, AND, U311, U611, U621, U411, U421, U111, U211, U911} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, U, ISNATILIST, ISNATKIND, ISNATILISTKIND, ISNAT} are not replacing on any position.

The TRS P consists of the following rules:

ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
U911(tt, IL, M, N) → U(N)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
U511(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 1 SCC with 1 less node.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
QCSDP
                    ↳ QCSDPReductionPairProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, TAKE} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U521, U511, U111, AND, U311, U611, U621, U411, U421, U211} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, ISNAT, U, ISNATILIST, ISNATKIND, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 1   
POL(AND(x1, x2)) = 2·x2   
POL(ISNAT(x1)) = 0   
POL(ISNATILIST(x1)) = 0   
POL(ISNATILISTKIND(x1)) = 0   
POL(ISNATKIND(x1)) = 0   
POL(ISNATLIST(x1)) = 0   
POL(TAKE(x1, x2)) = x1   
POL(U(x1)) = 2·x1   
POL(U11(x1, x2)) = 0   
POL(U111(x1, x2)) = 0   
POL(U12(x1)) = 2·x1   
POL(U21(x1, x2)) = x1   
POL(U211(x1, x2)) = 0   
POL(U22(x1)) = 0   
POL(U31(x1, x2)) = x1 + 2·x2   
POL(U311(x1, x2)) = x1   
POL(U32(x1)) = 0   
POL(U41(x1, x2, x3)) = 2·x1   
POL(U411(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = x1   
POL(U421(x1, x2)) = 2·x1   
POL(U43(x1)) = 0   
POL(U51(x1, x2, x3)) = 2·x1   
POL(U511(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = x1   
POL(U521(x1, x2)) = 0   
POL(U53(x1)) = 0   
POL(U61(x1, x2, x3)) = 2·x1   
POL(U611(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 2·x1   
POL(U621(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 1   
POL(U81(x1)) = 1   
POL(U91(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 0   
POL(isNat(x1)) = 0   
POL(isNatIList(x1)) = 2·x1   
POL(isNatIListKind(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatList(x1)) = 0   
POL(length(x1)) = 1   
POL(nil) = 0   
POL(s(x1)) = 1   
POL(take(x1, x2)) = 2·x1 + x2   
POL(tt) = 0   
POL(zeros) = 2   

the following usable rules

isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
and(tt, X) → X
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
TAKE(0, IL) → ISNATILIST(IL)

could be oriented strictly and thus removed.
The pairs

U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
QCSDP
                        ↳ QCSDependencyGraphProof
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, TAKE} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U521, U511, U111, AND, U311, U611, U621, U411, U421, U211} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, ISNAT, U, ISNATILIST, ISNATKIND, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U511(tt, V1, V2) → U521(isNat(V1), V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(take(M, IL)) → TAKE(M, IL)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
U611(tt, V1, V2) → ISNAT(V1)
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 2 SCCs with 10 less nodes.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
QCSDP
                              ↳ QCSDPReductionPairProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = 2·x2   
POL(ISNATILISTKIND(x1)) = 0   
POL(ISNATKIND(x1)) = 0   
POL(U(x1)) = x1   
POL(U11(x1, x2)) = 2 + x1 + x2   
POL(U12(x1)) = 1 + 2·x1   
POL(U21(x1, x2)) = 1   
POL(U22(x1)) = 1   
POL(U31(x1, x2)) = 1   
POL(U32(x1)) = 0   
POL(U41(x1, x2, x3)) = x1   
POL(U42(x1, x2)) = 0   
POL(U43(x1)) = 0   
POL(U51(x1, x2, x3)) = x1   
POL(U52(x1, x2)) = 0   
POL(U53(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 1   
POL(U81(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = 2·x1 + 2·x2   
POL(cons(x1, x2)) = 1   
POL(isNat(x1)) = 2 + x1   
POL(isNatIList(x1)) = 1   
POL(isNatIListKind(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatList(x1)) = 0   
POL(length(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1 + x1 + 2·x2   
POL(tt) = 0   
POL(zeros) = 2   

the following usable rules

take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
and(tt, X) → X
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))

could all be oriented weakly.
Furthermore, the pairs

U(take(x_0, x_1)) → U(x_0)
U(take(x_0, x_1)) → U(x_1)

could be oriented strictly and thus removed.
The pairs

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
QCSDP
                                  ↳ QCSDPReductionPairProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = 1 + x2   
POL(ISNATILISTKIND(x1)) = 1 + 2·x1   
POL(ISNATKIND(x1)) = 2·x1   
POL(U(x1)) = 1 + x1   
POL(U11(x1, x2)) = 0   
POL(U12(x1)) = x1   
POL(U21(x1, x2)) = 0   
POL(U22(x1)) = x1   
POL(U31(x1, x2)) = 0   
POL(U32(x1)) = 2·x1   
POL(U41(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = 2·x1   
POL(U43(x1)) = 2·x1   
POL(U51(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 0   
POL(U53(x1)) = x1   
POL(U61(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = x1   
POL(U63(x1)) = x1   
POL(U71(x1, x2)) = 1 + x2   
POL(U81(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 2·x2 + 2·x3 + 2·x4   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(isNat(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListKind(x1)) = 2·x1   
POL(isNatKind(x1)) = 2·x1   
POL(isNatList(x1)) = 0   
POL(length(x1)) = 1 + x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2·x1 + 2·x2   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

and(tt, X) → X
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)

could be oriented strictly and thus removed.
The pairs

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATKIND(s(V1)) → ISNATKIND(V1)

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
QCSDP
                                      ↳ QCSDependencyGraphProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATKIND(s(V1)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 2 SCCs.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
QCSDP
                                            ↳ QCSDPSubtermProof
                                          ↳ QCSDP
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

ISNATKIND(s(V1)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


ISNATKIND(s(V1)) → ISNATKIND(V1)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
ISNATKIND(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                            ↳ QCSDPSubtermProof
QCSDP
                                                ↳ PIsEmptyProof
                                          ↳ QCSDP
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
QCSDP
                                            ↳ QCSDPReductionPairProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = x2   
POL(ISNATILISTKIND(x1)) = x1   
POL(U(x1)) = x1   
POL(U11(x1, x2)) = 2   
POL(U12(x1)) = 2 + x1   
POL(U21(x1, x2)) = 2 + x2   
POL(U22(x1)) = 1   
POL(U31(x1, x2)) = 1 + x2   
POL(U32(x1)) = 1 + x1   
POL(U41(x1, x2, x3)) = 1 + 2·x3   
POL(U42(x1, x2)) = 1   
POL(U43(x1)) = 1   
POL(U51(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 0   
POL(U53(x1)) = x1   
POL(U61(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 2·x2   
POL(U81(x1)) = 1   
POL(U91(x1, x2, x3, x4)) = 1 + 2·x2 + 2·x3 + 2·x4   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(isNat(x1)) = 2 + 2·x1   
POL(isNatIList(x1)) = 1 + 2·x1   
POL(isNatIListKind(x1)) = x1   
POL(isNatKind(x1)) = x1   
POL(isNatList(x1)) = 0   
POL(length(x1)) = 2·x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + 2·x1 + 2·x2   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

and(tt, X) → X
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))

could be oriented strictly and thus removed.
The pairs

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                          ↳ QCSDP
                                            ↳ QCSDPReductionPairProof
QCSDP
                                                ↳ QCSDPNarrowingProcessor
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the Context-Sensitive Narrowing Processor
the pair ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
was transformed to the following new pairs:

ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))
ISNATILISTKIND(cons(length(x0), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(s(x0), y1)) → AND(isNatKind(x0), isNatIListKind(y1))



↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                          ↳ QCSDP
                                            ↳ QCSDPReductionPairProof
                                              ↳ QCSDP
                                                ↳ QCSDPNarrowingProcessor
QCSDP
                                                    ↳ QCSDPReductionPairProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(x0), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))
ISNATILISTKIND(cons(length(x0), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = 2·x2   
POL(ISNATILISTKIND(x1)) = 2·x1   
POL(U(x1)) = 2·x1   
POL(U11(x1, x2)) = x1 + x2   
POL(U12(x1)) = 0   
POL(U21(x1, x2)) = 2·x2   
POL(U22(x1)) = 0   
POL(U31(x1, x2)) = 2 + x1   
POL(U32(x1)) = 2   
POL(U41(x1, x2, x3)) = 1 + 2·x2 + 2·x3   
POL(U42(x1, x2)) = x1   
POL(U43(x1)) = 0   
POL(U51(x1, x2, x3)) = 2·x2 + 2·x3   
POL(U52(x1, x2)) = x2   
POL(U53(x1)) = 0   
POL(U61(x1, x2, x3)) = x2 + 2·x3   
POL(U62(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 2 + x2   
POL(U81(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = x2 + 2·x3 + 2·x4   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(isNat(x1)) = 2·x1   
POL(isNatIList(x1)) = 2 + 2·x1   
POL(isNatIListKind(x1)) = x1   
POL(isNatKind(x1)) = x1   
POL(isNatList(x1)) = 2·x1   
POL(length(x1)) = 2 + x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2·x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

and(tt, X) → X
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

ISNATILISTKIND(cons(length(x0), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))

could be oriented strictly and thus removed.
The pairs

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(x0), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                          ↳ QCSDP
                                            ↳ QCSDPReductionPairProof
                                              ↳ QCSDP
                                                ↳ QCSDPNarrowingProcessor
                                                  ↳ QCSDP
                                                    ↳ QCSDPReductionPairProof
QCSDP
                                                        ↳ QCSDPNarrowingProcessor
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(x0), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the Context-Sensitive Narrowing Processor
the pair ISNATILISTKIND(cons(s(x0), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
was transformed to the following new pairs:

ISNATILISTKIND(cons(s(0), y1)) → AND(tt, isNatIListKind(y1))
ISNATILISTKIND(cons(s(length(x0)), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(s(s(x0)), y1)) → AND(isNatKind(x0), isNatIListKind(y1))



↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                          ↳ QCSDP
                                            ↳ QCSDPReductionPairProof
                                              ↳ QCSDP
                                                ↳ QCSDPNarrowingProcessor
                                                  ↳ QCSDP
                                                    ↳ QCSDPReductionPairProof
                                                      ↳ QCSDP
                                                        ↳ QCSDPNarrowingProcessor
QCSDP
                                                            ↳ QCSDPReductionPairProof
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(s(length(x0)), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(s(0), y1)) → AND(tt, isNatIListKind(y1))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(s(x0)), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using the order
Polynomial interpretation [25]:

POL(0) = 0   
POL(AND(x1, x2)) = x2   
POL(ISNATILISTKIND(x1)) = 2·x1   
POL(U(x1)) = x1   
POL(U11(x1, x2)) = 0   
POL(U12(x1)) = 2·x1   
POL(U21(x1, x2)) = 2   
POL(U22(x1)) = 1   
POL(U31(x1, x2)) = 2   
POL(U32(x1)) = 0   
POL(U41(x1, x2, x3)) = 2   
POL(U42(x1, x2)) = 1   
POL(U43(x1)) = 1   
POL(U51(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 0   
POL(U53(x1)) = 2·x1   
POL(U61(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U71(x1, x2)) = 2 + x2   
POL(U81(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = x2 + 2·x3 + 2·x4   
POL(and(x1, x2)) = 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(isNat(x1)) = 2   
POL(isNatIList(x1)) = 2   
POL(isNatIListKind(x1)) = 2·x1   
POL(isNatKind(x1)) = 2·x1   
POL(isNatList(x1)) = 0   
POL(length(x1)) = 2 + x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 2·x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

and(tt, X) → X
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeroscons(0, zeros)
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71(tt, L) → s(length(L))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U81(tt) → nil
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U91(tt, IL, M, N) → cons(N, take(M, IL))
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt

could all be oriented weakly.
Furthermore, the pairs

ISNATILISTKIND(cons(s(length(x0)), y1)) → AND(isNatIListKind(x0), isNatIListKind(y1))

could be oriented strictly and thus removed.
The pairs

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(s(0), y1)) → AND(tt, isNatIListKind(y1))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(s(x0)), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))

could only be oriented weakly and must be analyzed further.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
                              ↳ QCSDPReductionPairProof
                                ↳ QCSDP
                                  ↳ QCSDPReductionPairProof
                                    ↳ QCSDP
                                      ↳ QCSDependencyGraphProof
                                        ↳ AND
                                          ↳ QCSDP
                                          ↳ QCSDP
                                            ↳ QCSDPReductionPairProof
                                              ↳ QCSDP
                                                ↳ QCSDPNarrowingProcessor
                                                  ↳ QCSDP
                                                    ↳ QCSDPReductionPairProof
                                                      ↳ QCSDP
                                                        ↳ QCSDPNarrowingProcessor
                                                          ↳ QCSDP
                                                            ↳ QCSDPReductionPairProof
QCSDP
                            ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, AND} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(cons(s(0), y1)) → AND(tt, isNatIListKind(y1))
AND(tt, X) → U(X)
ISNATILISTKIND(cons(s(s(x0)), y1)) → AND(isNatKind(x0), isNatIListKind(y1))
ISNATILISTKIND(cons(0, y1)) → AND(tt, isNatIListKind(y1))

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPReductionPairProof
              ↳ QCSDP
                ↳ QCSDependencyGraphProof
                  ↳ QCSDP
                    ↳ QCSDPReductionPairProof
                      ↳ QCSDP
                        ↳ QCSDependencyGraphProof
                          ↳ AND
                            ↳ QCSDP
QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U521, U511, U111, U611, U621, U311, U411, U421, U211} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind, ISNATLIST, ISNAT, ISNATILIST} are not replacing on any position.

The TRS P consists of the following rules:

U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U611(tt, V1, V2) → U621(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
ISNATILIST(V) → U311(isNatIListKind(V), V)
U311(tt, V) → ISNATLIST(V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U421(tt, V2) → ISNATILIST(V2)
U411(tt, V1, V2) → ISNAT(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
U211(tt, V1) → ISNAT(V1)
U611(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {U12, U22, U32, U43, U53, U63, s, length, U81, take, LENGTH} are replacing on all positions.
For all symbols f in {cons, U11, U21, U31, U41, U42, U51, U52, U61, U62, U71, U91, and, U711} we have µ(f) = {1}.
The symbols in {isNatList, isNat, isNatIList, isNatIListKind, isNatKind} are not replacing on any position.

The TRS P consists of the following rules:

U711(tt, L) → LENGTH(L)
LENGTH(cons(N, L)) → U711(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

We applied the Incomplete Giesl Middeldorp transformation [11] to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
QTRS
      ↳ DependencyPairsProof
  ↳ Trivial-Transformation

Q restricted rewrite system:
The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MARK(U11(x1, x2)) → MARK(x1)
U11ACTIVE(tt, V1) → U12ACTIVE(isNatListActive(V1))
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → U53ACTIVE(mark(x1))
MARK(U63(x1)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U43(x1)) → U43ACTIVE(mark(x1))
MARK(U32(x1)) → MARK(x1)
U71ACTIVE(tt, L) → MARK(L)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U21ACTIVE(tt, V1) → U22ACTIVE(isNatActive(V1))
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
MARK(s(x1)) → MARK(x1)
MARK(U91(x1, x2, x3, x4)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U62(x1, x2)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U22(x1)) → U22ACTIVE(mark(x1))
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U71(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
MARK(U91(x1, x2, x3, x4)) → U91ACTIVE(mark(x1), x2, x3, x4)
U31ACTIVE(tt, V) → U32ACTIVE(isNatListActive(V))
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
TAKEACTIVE(0, IL) → U81ACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)))
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
U91ACTIVE(tt, IL, M, N) → MARK(N)
ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
TAKEACTIVE(0, IL) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U12(x1)) → U12ACTIVE(mark(x1))
MARK(U32(x1)) → U32ACTIVE(mark(x1))
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(take(x1, x2)) → MARK(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U81(x1)) → U81ACTIVE(mark(x1))
MARK(U22(x1)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → U91ACTIVE(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U12(x1)) → MARK(x1)
MARK(U52(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U81(x1)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
MARK(zeros) → ZEROSACTIVE
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → U43ACTIVE(isNatIListActive(V2))
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
U52ACTIVE(tt, V2) → U53ACTIVE(isNatListActive(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U63(x1)) → U63ACTIVE(mark(x1))
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
U62ACTIVE(tt, V2) → U63ACTIVE(isNatIListActive(V2))
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
QDP
          ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U11(x1, x2)) → MARK(x1)
U11ACTIVE(tt, V1) → U12ACTIVE(isNatListActive(V1))
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → U53ACTIVE(mark(x1))
MARK(U63(x1)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U43(x1)) → U43ACTIVE(mark(x1))
MARK(U32(x1)) → MARK(x1)
U71ACTIVE(tt, L) → MARK(L)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U21ACTIVE(tt, V1) → U22ACTIVE(isNatActive(V1))
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
MARK(s(x1)) → MARK(x1)
MARK(U91(x1, x2, x3, x4)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U62(x1, x2)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U22(x1)) → U22ACTIVE(mark(x1))
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U71(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
MARK(U91(x1, x2, x3, x4)) → U91ACTIVE(mark(x1), x2, x3, x4)
U31ACTIVE(tt, V) → U32ACTIVE(isNatListActive(V))
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
TAKEACTIVE(0, IL) → U81ACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)))
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
U91ACTIVE(tt, IL, M, N) → MARK(N)
ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
TAKEACTIVE(0, IL) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U12(x1)) → U12ACTIVE(mark(x1))
MARK(U32(x1)) → U32ACTIVE(mark(x1))
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(take(x1, x2)) → MARK(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U81(x1)) → U81ACTIVE(mark(x1))
MARK(U22(x1)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → U91ACTIVE(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U12(x1)) → MARK(x1)
MARK(U52(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U81(x1)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
MARK(zeros) → ZEROSACTIVE
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → U43ACTIVE(isNatIListActive(V2))
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
U52ACTIVE(tt, V2) → U53ACTIVE(isNatListActive(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U63(x1)) → U63ACTIVE(mark(x1))
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
U62ACTIVE(tt, V2) → U63ACTIVE(isNatIListActive(V2))
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 15 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
QDP
              ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
U91ACTIVE(tt, IL, M, N) → MARK(N)
ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(take(x1, x2)) → MARK(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
TAKEACTIVE(s(M), cons(N, IL)) → U91ACTIVE(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(take(x1, x2)) → MARK(x2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
MARK(U91(x1, x2, x3, x4)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U81(x1)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U71(x1, x2)) → MARK(x1)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
MARK(U91(x1, x2, x3, x4)) → U91ACTIVE(mark(x1), x2, x3, x4)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


MARK(take(x1, x2)) → MARK(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U91(x1, x2, x3, x4)) → MARK(x1)
MARK(U81(x1)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U91(x1, x2, x3, x4)) → U91ACTIVE(mark(x1), x2, x3, x4)
The remaining pairs can at least be oriented weakly.

TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
U91ACTIVE(tt, IL, M, N) → MARK(N)
ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
TAKEACTIVE(s(M), cons(N, IL)) → U91ACTIVE(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U71(x1, x2)) → MARK(x1)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(ANDACTIVE(x1, x2)) = x2   
POL(ISNATACTIVE(x1)) = 0   
POL(ISNATILISTACTIVE(x1)) = 0   
POL(ISNATILISTKINDACTIVE(x1)) = 0   
POL(ISNATKINDACTIVE(x1)) = 0   
POL(ISNATLISTACTIVE(x1)) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(MARK(x1)) = x1   
POL(TAKEACTIVE(x1, x2)) = x2   
POL(U11(x1, x2)) = x1   
POL(U11ACTIVE(x1, x2)) = 0   
POL(U11Active(x1, x2)) = x1   
POL(U12(x1)) = x1   
POL(U12Active(x1)) = x1   
POL(U21(x1, x2)) = x1   
POL(U21ACTIVE(x1, x2)) = 0   
POL(U21Active(x1, x2)) = x1   
POL(U22(x1)) = x1   
POL(U22Active(x1)) = x1   
POL(U31(x1, x2)) = x1   
POL(U31ACTIVE(x1, x2)) = 0   
POL(U31Active(x1, x2)) = x1   
POL(U32(x1)) = x1   
POL(U32Active(x1)) = x1   
POL(U41(x1, x2, x3)) = x1   
POL(U41ACTIVE(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = x1   
POL(U42(x1, x2)) = x1   
POL(U42ACTIVE(x1, x2)) = 0   
POL(U42Active(x1, x2)) = x1   
POL(U43(x1)) = x1   
POL(U43Active(x1)) = x1   
POL(U51(x1, x2, x3)) = x1   
POL(U51ACTIVE(x1, x2, x3)) = 0   
POL(U51Active(x1, x2, x3)) = x1   
POL(U52(x1, x2)) = x1   
POL(U52ACTIVE(x1, x2)) = 0   
POL(U52Active(x1, x2)) = x1   
POL(U53(x1)) = x1   
POL(U53Active(x1)) = x1   
POL(U61(x1, x2, x3)) = x1   
POL(U61ACTIVE(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = x1   
POL(U62(x1, x2)) = x1   
POL(U62ACTIVE(x1, x2)) = 0   
POL(U62Active(x1, x2)) = x1   
POL(U63(x1)) = x1   
POL(U63Active(x1)) = x1   
POL(U71(x1, x2)) = x1 + x2   
POL(U71ACTIVE(x1, x2)) = x2   
POL(U71Active(x1, x2)) = x1 + x2   
POL(U81(x1)) = 1 + x1   
POL(U81Active(x1)) = 1 + x1   
POL(U91(x1, x2, x3, x4)) = 1 + x1 + x2 + x3 + x4   
POL(U91ACTIVE(x1, x2, x3, x4)) = x4   
POL(U91Active(x1, x2, x3, x4)) = 1 + x1 + x2 + x3 + x4   
POL(and(x1, x2)) = x1 + x2   
POL(andActive(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = x1 + x2   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 0   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + x1 + x2   
POL(takeActive(x1, x2)) = 1 + x1 + x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
QDP
                  ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
U91ACTIVE(tt, IL, M, N) → MARK(N)
ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
TAKEACTIVE(s(M), cons(N, IL)) → U91ACTIVE(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U31(x1, x2)) → MARK(x1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
MARK(U61(x1, x2, x3)) → MARK(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), isNatIListKind(IL))
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 7 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
QDP
                      ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U21(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U71(x1, x2)) → MARK(x1)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


MARK(length(x1)) → MARK(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U71(x1, x2)) → MARK(x1)
The remaining pairs can at least be oriented weakly.

ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U21(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(ANDACTIVE(x1, x2)) = x2   
POL(ISNATACTIVE(x1)) = 0   
POL(ISNATILISTACTIVE(x1)) = 0   
POL(ISNATILISTKINDACTIVE(x1)) = 0   
POL(ISNATKINDACTIVE(x1)) = 0   
POL(ISNATLISTACTIVE(x1)) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(MARK(x1)) = x1   
POL(U11(x1, x2)) = x1   
POL(U11ACTIVE(x1, x2)) = 0   
POL(U11Active(x1, x2)) = x1   
POL(U12(x1)) = x1   
POL(U12Active(x1)) = x1   
POL(U21(x1, x2)) = x1   
POL(U21ACTIVE(x1, x2)) = 0   
POL(U21Active(x1, x2)) = x1   
POL(U22(x1)) = x1   
POL(U22Active(x1)) = x1   
POL(U31(x1, x2)) = x1   
POL(U31ACTIVE(x1, x2)) = 0   
POL(U31Active(x1, x2)) = x1   
POL(U32(x1)) = x1   
POL(U32Active(x1)) = x1   
POL(U41(x1, x2, x3)) = x1   
POL(U41ACTIVE(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = x1   
POL(U42(x1, x2)) = x1   
POL(U42ACTIVE(x1, x2)) = 0   
POL(U42Active(x1, x2)) = x1   
POL(U43(x1)) = x1   
POL(U43Active(x1)) = x1   
POL(U51(x1, x2, x3)) = x1   
POL(U51ACTIVE(x1, x2, x3)) = 0   
POL(U51Active(x1, x2, x3)) = x1   
POL(U52(x1, x2)) = x1   
POL(U52ACTIVE(x1, x2)) = 0   
POL(U52Active(x1, x2)) = x1   
POL(U53(x1)) = x1   
POL(U53Active(x1)) = x1   
POL(U61(x1, x2, x3)) = x1   
POL(U61ACTIVE(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = x1   
POL(U62(x1, x2)) = x1   
POL(U62ACTIVE(x1, x2)) = 0   
POL(U62Active(x1, x2)) = x1   
POL(U63(x1)) = x1   
POL(U63Active(x1)) = x1   
POL(U71(x1, x2)) = 1 + x1 + x2   
POL(U71ACTIVE(x1, x2)) = x2   
POL(U71Active(x1, x2)) = 1 + x1 + x2   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 1 + x2 + x4   
POL(U91Active(x1, x2, x3, x4)) = 1 + x2 + x4   
POL(and(x1, x2)) = x1 + x2   
POL(andActive(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = x1 + x2   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 0   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = 1 + x1   
POL(lengthActive(x1)) = 1 + x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = x1   
POL(take(x1, x2)) = 1 + x2   
POL(takeActive(x1, x2)) = 1 + x2   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
QDP
                          ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U71ACTIVE(tt, L) → MARK(L)
MARK(U22(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U21(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
MARK(and(x1, x2)) → MARK(x1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 4 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
QDP
                                ↳ QDPOrderProof
                              ↳ QDP
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U22(x1)) → MARK(x1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
MARK(U21(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


ISNATLISTACTIVE(take(V1, V2)) → U61ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U11(x1, x2)) → MARK(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U51(x1, x2, x3)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
MARK(U63(x1)) → MARK(x1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U32(x1)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U21(x1, x2)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U42(x1, x2)) → MARK(x1)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U12(x1)) → MARK(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(U62(x1, x2)) → U62ACTIVE(mark(x1), x2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → MARK(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(U61(x1, x2, x3)) → U61ACTIVE(mark(x1), x2, x3)
ISNATILISTKINDACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U62(x1, x2)) → MARK(x1)
U61ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATLISTACTIVE(take(V1, V2)) → ISNATKINDACTIVE(V1)
The remaining pairs can at least be oriented weakly.

U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(ANDACTIVE(x1, x2)) = 1 + x2   
POL(ISNATACTIVE(x1)) = x1   
POL(ISNATILISTACTIVE(x1)) = 1 + x1   
POL(ISNATILISTKINDACTIVE(x1)) = 1 + x1   
POL(ISNATKINDACTIVE(x1)) = 1 + x1   
POL(ISNATLISTACTIVE(x1)) = 1 + x1   
POL(MARK(x1)) = 1 + x1   
POL(U11(x1, x2)) = 1 + x1 + x2   
POL(U11ACTIVE(x1, x2)) = 1 + x2   
POL(U11Active(x1, x2)) = 0   
POL(U12(x1)) = 1 + x1   
POL(U12Active(x1)) = 0   
POL(U21(x1, x2)) = 1 + x1 + x2   
POL(U21ACTIVE(x1, x2)) = 1 + x2   
POL(U21Active(x1, x2)) = 0   
POL(U22(x1)) = 1 + x1   
POL(U22Active(x1)) = 0   
POL(U31(x1, x2)) = 1 + x1 + x2   
POL(U31ACTIVE(x1, x2)) = 1 + x2   
POL(U31Active(x1, x2)) = 0   
POL(U32(x1)) = 1 + x1   
POL(U32Active(x1)) = 0   
POL(U41(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(U41ACTIVE(x1, x2, x3)) = 1 + x2 + x3   
POL(U41Active(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = 1 + x1 + x2   
POL(U42ACTIVE(x1, x2)) = 1 + x2   
POL(U42Active(x1, x2)) = 0   
POL(U43(x1)) = 1 + x1   
POL(U43Active(x1)) = 0   
POL(U51(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(U51ACTIVE(x1, x2, x3)) = 1 + x2 + x3   
POL(U51Active(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 1 + x1 + x2   
POL(U52ACTIVE(x1, x2)) = 1 + x2   
POL(U52Active(x1, x2)) = 0   
POL(U53(x1)) = 1 + x1   
POL(U53Active(x1)) = 0   
POL(U61(x1, x2, x3)) = 1 + x1 + x2 + x3   
POL(U61ACTIVE(x1, x2, x3)) = 1 + x2 + x3   
POL(U61Active(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 1 + x1 + x2   
POL(U62ACTIVE(x1, x2)) = 1 + x2   
POL(U62Active(x1, x2)) = 0   
POL(U63(x1)) = 1 + x1   
POL(U63Active(x1)) = 0   
POL(U71(x1, x2)) = 0   
POL(U71Active(x1, x2)) = 0   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 0   
POL(U91Active(x1, x2, x3, x4)) = 0   
POL(and(x1, x2)) = 1 + x1 + x2   
POL(andActive(x1, x2)) = 0   
POL(cons(x1, x2)) = 1 + x1 + x2   
POL(isNat(x1)) = x1   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 1 + x1   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 1 + x1   
POL(isNatIListKindActive(x1)) = 0   
POL(isNatKind(x1)) = 1 + x1   
POL(isNatKindActive(x1)) = 0   
POL(isNatList(x1)) = 1 + x1   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = 1 + x1   
POL(lengthActive(x1)) = 0   
POL(mark(x1)) = 0   
POL(nil) = 0   
POL(s(x1)) = 1 + x1   
POL(take(x1, x2)) = 1 + x1 + x2   
POL(takeActive(x1, x2)) = 0   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [17] were oriented: none



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                                ↳ QDPOrderProof
QDP
                                    ↳ DependencyGraphProof
                              ↳ QDP
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

ISNATACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
ISNATILISTKINDACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(V) → U31ACTIVE(isNatIListKindActive(V), V)
U62ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U11ACTIVE(tt, V1) → ISNATLISTACTIVE(V1)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATACTIVE(length(V1)) → U11ACTIVE(isNatIListKindActive(V1), V1)
ANDACTIVE(tt, X) → MARK(X)
U31ACTIVE(tt, V) → ISNATLISTACTIVE(V)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
U61ACTIVE(tt, V1, V2) → U62ACTIVE(isNatActive(V1), V2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATILISTACTIVE(V) → ISNATILISTKINDACTIVE(V)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 20 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U71ACTIVE(tt, L) → LENGTHACTIVE(mark(L)) at position [0] we obtained the following new rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, s(x0)) → LENGTHACTIVE(s(mark(x0)))
U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, tt) → LENGTHACTIVE(tt)
U71ACTIVE(tt, 0) → LENGTHACTIVE(0)
U71ACTIVE(tt, nil) → LENGTHACTIVE(nil)
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
QDP
                                    ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, s(x0)) → LENGTHACTIVE(s(mark(x0)))
U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, tt) → LENGTHACTIVE(tt)
U71ACTIVE(tt, 0) → LENGTHACTIVE(0)
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, nil) → LENGTHACTIVE(nil)
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
QDP
                                        ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U71ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive) at position [0] we obtained the following new rules:

U71ACTIVE(tt, zeros) → LENGTHACTIVE(zeros)
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
QDP
                                            ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(zeros)
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
QDP
                                                ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


U71ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U71ACTIVE(tt, U81(x0)) → LENGTHACTIVE(U81Active(mark(x0)))
U71ACTIVE(tt, U71(x0, x1)) → LENGTHACTIVE(U71Active(mark(x0), x1))
The remaining pairs can at least be oriented weakly.

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(U11(x1, x2)) = 0   
POL(U11Active(x1, x2)) = 1   
POL(U12(x1)) = 1   
POL(U12Active(x1)) = 1   
POL(U21(x1, x2)) = x1   
POL(U21Active(x1, x2)) = x1   
POL(U22(x1)) = 1   
POL(U22Active(x1)) = 1   
POL(U31(x1, x2)) = x1   
POL(U31Active(x1, x2)) = x1   
POL(U32(x1)) = 1   
POL(U32Active(x1)) = 1   
POL(U41(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = 1   
POL(U42(x1, x2)) = 0   
POL(U42Active(x1, x2)) = 1   
POL(U43(x1)) = 0   
POL(U43Active(x1)) = 1   
POL(U51(x1, x2, x3)) = x1   
POL(U51Active(x1, x2, x3)) = x1   
POL(U52(x1, x2)) = 1   
POL(U52Active(x1, x2)) = 1   
POL(U53(x1)) = 0   
POL(U53Active(x1)) = 1   
POL(U61(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = 1   
POL(U62(x1, x2)) = 0   
POL(U62Active(x1, x2)) = x1   
POL(U63(x1)) = 0   
POL(U63Active(x1)) = 1   
POL(U71(x1, x2)) = 0   
POL(U71ACTIVE(x1, x2)) = x1   
POL(U71Active(x1, x2)) = 0   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 0   
POL(U91Active(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = 0   
POL(andActive(x1, x2)) = x1   
POL(cons(x1, x2)) = 1   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 1   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 1   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 1   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 1   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 1   
POL(length(x1)) = 0   
POL(lengthActive(x1)) = 0   
POL(mark(x1)) = 1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
QDP
                                                    ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


U71ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U71ACTIVE(tt, U53(x0)) → LENGTHACTIVE(U53Active(mark(x0)))
U71ACTIVE(tt, U42(x0, x1)) → LENGTHACTIVE(U42Active(mark(x0), x1))
U71ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U71ACTIVE(tt, U61(x0, x1, x2)) → LENGTHACTIVE(U61Active(mark(x0), x1, x2))
U71ACTIVE(tt, U12(x0)) → LENGTHACTIVE(U12Active(mark(x0)))
U71ACTIVE(tt, U43(x0)) → LENGTHACTIVE(U43Active(mark(x0)))
U71ACTIVE(tt, U52(x0, x1)) → LENGTHACTIVE(U52Active(mark(x0), x1))
U71ACTIVE(tt, U63(x0)) → LENGTHACTIVE(U63Active(mark(x0)))
U71ACTIVE(tt, U21(x0, x1)) → LENGTHACTIVE(U21Active(mark(x0), x1))
U71ACTIVE(tt, U41(x0, x1, x2)) → LENGTHACTIVE(U41Active(mark(x0), x1, x2))
U71ACTIVE(tt, U31(x0, x1)) → LENGTHACTIVE(U31Active(mark(x0), x1))
U71ACTIVE(tt, U51(x0, x1, x2)) → LENGTHACTIVE(U51Active(mark(x0), x1, x2))
U71ACTIVE(tt, U62(x0, x1)) → LENGTHACTIVE(U62Active(mark(x0), x1))
U71ACTIVE(tt, U32(x0)) → LENGTHACTIVE(U32Active(mark(x0)))
U71ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U71ACTIVE(tt, U22(x0)) → LENGTHACTIVE(U22Active(mark(x0)))
U71ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
The remaining pairs can at least be oriented weakly.

U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(U11(x1, x2)) = 0   
POL(U11Active(x1, x2)) = 0   
POL(U12(x1)) = 0   
POL(U12Active(x1)) = 0   
POL(U21(x1, x2)) = 0   
POL(U21Active(x1, x2)) = 0   
POL(U22(x1)) = 0   
POL(U22Active(x1)) = 0   
POL(U31(x1, x2)) = 0   
POL(U31Active(x1, x2)) = 0   
POL(U32(x1)) = 0   
POL(U32Active(x1)) = 0   
POL(U41(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = 0   
POL(U42Active(x1, x2)) = 0   
POL(U43(x1)) = 0   
POL(U43Active(x1)) = 0   
POL(U51(x1, x2, x3)) = 0   
POL(U51Active(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 0   
POL(U52Active(x1, x2)) = 0   
POL(U53(x1)) = 0   
POL(U53Active(x1)) = 0   
POL(U61(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U62Active(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U63Active(x1)) = 0   
POL(U71(x1, x2)) = 0   
POL(U71ACTIVE(x1, x2)) = 1   
POL(U71Active(x1, x2)) = 0   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 0   
POL(U91Active(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = 0   
POL(andActive(x1, x2)) = 1   
POL(cons(x1, x2)) = 1   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 1   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 1   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = 0   
POL(lengthActive(x1)) = 1   
POL(mark(x1)) = 1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 0   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
QDP
                                                        ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


U71ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U71ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U71ACTIVE(tt, U91(x0, x1, x2, x3)) → LENGTHACTIVE(U91Active(mark(x0), x1, x2, x3))
The remaining pairs can at least be oriented weakly.

U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(U11(x1, x2)) = 0   
POL(U11Active(x1, x2)) = 0   
POL(U12(x1)) = 0   
POL(U12Active(x1)) = 0   
POL(U21(x1, x2)) = 0   
POL(U21Active(x1, x2)) = 0   
POL(U22(x1)) = x1   
POL(U22Active(x1)) = x1   
POL(U31(x1, x2)) = 0   
POL(U31Active(x1, x2)) = 0   
POL(U32(x1)) = 0   
POL(U32Active(x1)) = 0   
POL(U41(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = 0   
POL(U42Active(x1, x2)) = 0   
POL(U43(x1)) = 0   
POL(U43Active(x1)) = 0   
POL(U51(x1, x2, x3)) = 0   
POL(U51Active(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = x1   
POL(U52Active(x1, x2)) = x1   
POL(U53(x1)) = x1   
POL(U53Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U62Active(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U63Active(x1)) = 0   
POL(U71(x1, x2)) = x2   
POL(U71ACTIVE(x1, x2)) = 1 + x2   
POL(U71Active(x1, x2)) = 1 + x2   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 1   
POL(U91Active(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = 1 + x2   
POL(andActive(x1, x2)) = 1 + x2   
POL(cons(x1, x2)) = 1 + x2   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 1   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 1   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = 1 + x1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 0   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
QDP
                                                            ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


U71ACTIVE(tt, isNatIListKind(x0)) → LENGTHACTIVE(isNatIListKindActive(x0))
U71ACTIVE(tt, isNatKind(x0)) → LENGTHACTIVE(isNatKindActive(x0))
The remaining pairs can at least be oriented weakly.

U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(U11(x1, x2)) = x1   
POL(U11Active(x1, x2)) = x1   
POL(U12(x1)) = 0   
POL(U12Active(x1)) = 0   
POL(U21(x1, x2)) = 0   
POL(U21Active(x1, x2)) = 0   
POL(U22(x1)) = x1   
POL(U22Active(x1)) = x1   
POL(U31(x1, x2)) = 0   
POL(U31Active(x1, x2)) = 0   
POL(U32(x1)) = 0   
POL(U32Active(x1)) = 0   
POL(U41(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = 0   
POL(U42(x1, x2)) = 0   
POL(U42Active(x1, x2)) = 0   
POL(U43(x1)) = 0   
POL(U43Active(x1)) = 0   
POL(U51(x1, x2, x3)) = 0   
POL(U51Active(x1, x2, x3)) = 0   
POL(U52(x1, x2)) = 0   
POL(U52Active(x1, x2)) = 0   
POL(U53(x1)) = 0   
POL(U53Active(x1)) = 0   
POL(U61(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = 0   
POL(U62(x1, x2)) = 0   
POL(U62Active(x1, x2)) = 0   
POL(U63(x1)) = 0   
POL(U63Active(x1)) = 0   
POL(U71(x1, x2)) = 0   
POL(U71ACTIVE(x1, x2)) = 1   
POL(U71Active(x1, x2)) = 0   
POL(U81(x1)) = 0   
POL(U81Active(x1)) = 0   
POL(U91(x1, x2, x3, x4)) = 1   
POL(U91Active(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = x2   
POL(andActive(x1, x2)) = x2   
POL(cons(x1, x2)) = 1   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 0   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 0   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 0   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 0   
POL(isNatList(x1)) = 0   
POL(isNatListActive(x1)) = 0   
POL(length(x1)) = x1   
POL(lengthActive(x1)) = x1   
POL(mark(x1)) = x1   
POL(nil) = 0   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 0   
POL(zeros) = 1   
POL(zerosActive) = 1   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                                          ↳ QDP
                                                            ↳ QDPOrderProof
QDP
                                                                ↳ QDPOrderProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


U71ACTIVE(tt, zeros) → LENGTHACTIVE(cons(0, zeros))
The remaining pairs can at least be oriented weakly.

LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(LENGTHACTIVE(x1)) = x1   
POL(U11(x1, x2)) = x1   
POL(U11Active(x1, x2)) = x1   
POL(U12(x1)) = 0   
POL(U12Active(x1)) = 1   
POL(U21(x1, x2)) = 1   
POL(U21Active(x1, x2)) = 1   
POL(U22(x1)) = 1   
POL(U22Active(x1)) = 1   
POL(U31(x1, x2)) = 0   
POL(U31Active(x1, x2)) = 1   
POL(U32(x1)) = 0   
POL(U32Active(x1)) = 1   
POL(U41(x1, x2, x3)) = 0   
POL(U41Active(x1, x2, x3)) = 1   
POL(U42(x1, x2)) = 0   
POL(U42Active(x1, x2)) = 1   
POL(U43(x1)) = 0   
POL(U43Active(x1)) = 1   
POL(U51(x1, x2, x3)) = x3   
POL(U51Active(x1, x2, x3)) = x3   
POL(U52(x1, x2)) = x2   
POL(U52Active(x1, x2)) = x2   
POL(U53(x1)) = x1   
POL(U53Active(x1)) = x1   
POL(U61(x1, x2, x3)) = 0   
POL(U61Active(x1, x2, x3)) = 1   
POL(U62(x1, x2)) = x1   
POL(U62Active(x1, x2)) = x1   
POL(U63(x1)) = 1   
POL(U63Active(x1)) = 1   
POL(U71(x1, x2)) = 0   
POL(U71ACTIVE(x1, x2)) = x1   
POL(U71Active(x1, x2)) = 0   
POL(U81(x1)) = x1   
POL(U81Active(x1)) = x1   
POL(U91(x1, x2, x3, x4)) = 1   
POL(U91Active(x1, x2, x3, x4)) = 1   
POL(and(x1, x2)) = x1 + x2   
POL(andActive(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = x2   
POL(isNat(x1)) = 0   
POL(isNatActive(x1)) = 1   
POL(isNatIList(x1)) = 0   
POL(isNatIListActive(x1)) = 1   
POL(isNatIListKind(x1)) = 0   
POL(isNatIListKindActive(x1)) = 1   
POL(isNatKind(x1)) = 0   
POL(isNatKindActive(x1)) = 1   
POL(isNatList(x1)) = x1   
POL(isNatListActive(x1)) = x1   
POL(length(x1)) = 0   
POL(lengthActive(x1)) = 1   
POL(mark(x1)) = 1 + x1   
POL(nil) = 1   
POL(s(x1)) = 0   
POL(take(x1, x2)) = 1   
POL(takeActive(x1, x2)) = 1   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [17] were oriented:

mark(U11(x1, x2)) → U11Active(mark(x1), x2)
zerosActivezeros
mark(U12(x1)) → U12Active(mark(x1))
U11Active(x1, x2) → U11(x1, x2)
mark(zeros) → zerosActive
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U22Active(x1) → U22(x1)
mark(U32(x1)) → U32Active(mark(x1))
U31Active(x1, x2) → U31(x1, x2)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U12Active(x1) → U12(x1)
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(nil) → tt
isNatKindActive(0) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(nil) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListActive(zeros) → tt
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(0) → tt
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U21Active(tt, V1) → U22Active(isNatActive(V1))
U12Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U32Active(tt) → tt
U43Active(tt) → tt
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U53Active(tt) → tt
U63Active(tt) → tt
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U81Active(tt) → nil
U71Active(tt, L) → s(lengthActive(mark(L)))
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U63Active(x1) → U63(x1)
mark(U63(x1)) → U63Active(mark(x1))
U62Active(x1, x2) → U62(x1, x2)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U81Active(x1) → U81(x1)
mark(U81(x1)) → U81Active(mark(x1))
U71Active(x1, x2) → U71(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
andActive(x1, x2) → and(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatKindActive(s(V1)) → isNatKindActive(V1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(x1) → isNat(x1)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ DependencyGraphProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ DependencyGraphProof
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ QDPOrderProof
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
                                                      ↳ QDP
                                                        ↳ QDPOrderProof
                                                          ↳ QDP
                                                            ↳ QDPOrderProof
                                                              ↳ QDP
                                                                ↳ QDPOrderProof
QDP
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U71ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
LENGTHACTIVE(cons(N, L)) → U71ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActivezeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U12(x1)) → U12Active(mark(x1))
U12Active(x1) → U12(x1)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U32(x1)) → U32Active(mark(x1))
U32Active(x1) → U32(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2, x3)) → U61Active(mark(x1), x2, x3)
U61Active(x1, x2, x3) → U61(x1, x2, x3)
mark(U62(x1, x2)) → U62Active(mark(x1), x2)
U62Active(x1, x2) → U62(x1, x2)
mark(U63(x1)) → U63Active(mark(x1))
U63Active(x1) → U63(x1)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1)) → U81Active(mark(x1))
U81Active(x1) → U81(x1)
mark(U91(x1, x2, x3, x4)) → U91Active(mark(x1), x2, x3, x4)
U91Active(x1, x2, x3, x4) → U91(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActivecons(0, zeros)
U11Active(tt, V1) → U12Active(isNatListActive(V1))
U12Active(tt) → tt
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U31Active(tt, V) → U32Active(isNatListActive(V))
U32Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, V1, V2) → U62Active(isNatActive(V1), V2)
U62Active(tt, V2) → U63Active(isNatIListActive(V2))
U63Active(tt) → tt
U71Active(tt, L) → s(lengthActive(mark(L)))
U81Active(tt) → nil
U91Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → U11Active(isNatIListKindActive(V1), V1)
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(V) → U31Active(isNatIListKindActive(V), V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatIListKindActive(take(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatListActive(take(V1, V2)) → U61Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U71Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
takeActive(0, IL) → U81Active(andActive(isNatIListActive(IL), isNatIListKind(IL)))
takeActive(s(M), cons(N, IL)) → U91Active(andActive(andActive(isNatIListActive(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Trivial transformation to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
QTRS
      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → AND(isNatList(L), isNatIListKind(L))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → U421(isNat(V1), V2)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNATKIND(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(IL), isNatIListKind(IL))
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
LENGTH(cons(N, L)) → U711(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(cons(V1, V2)) → ISNATILISTKIND(V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATILIST(cons(V1, V2)) → ISNATILISTKIND(V2)
LENGTH(cons(N, L)) → ISNATILISTKIND(L)
TAKE(0, IL) → U811(and(isNatIList(IL), isNatIListKind(IL)))
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(0, IL) → ISNATILISTKIND(IL)
TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
LENGTH(cons(N, L)) → ISNAT(N)
ISNATILISTKIND(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
U611(tt, V1, V2) → U621(isNat(V1), V2)
ISNATKIND(s(V1)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → AND(isNat(M), isNatKind(M))
ISNATILIST(V) → U311(isNatIListKind(V), V)
U521(tt, V2) → U531(isNatList(V2))
TAKE(0, IL) → ISNATILIST(IL)
U211(tt, V1) → ISNAT(V1)
TAKE(s(M), cons(N, IL)) → AND(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → ISNATKIND(N)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U311(tt, V) → ISNATLIST(V)
ISNAT(s(V1)) → ISNATKIND(V1)
U621(tt, V2) → U631(isNatIList(V2))
TAKE(s(M), cons(N, IL)) → ISNATILISTKIND(IL)
ISNATLIST(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → AND(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
ZEROSZEROS
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(s(M), cons(N, IL)) → ISNATKIND(M)
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNATILIST(IL)
LENGTH(cons(N, L)) → ISNATLIST(L)
U621(tt, V2) → ISNATILIST(V2)
U111(tt, V1) → U121(isNatList(V1))
U421(tt, V2) → ISNATILIST(V2)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
TAKE(s(M), cons(N, IL)) → ISNAT(M)
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNAT(N)
U711(tt, L) → LENGTH(L)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
U911(tt, IL, M, N) → TAKE(M, IL)
U211(tt, V1) → U221(isNat(V1))
ISNATILISTKIND(cons(V1, V2)) → ISNATILISTKIND(V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
LENGTH(cons(N, L)) → AND(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → AND(isNat(N), isNatKind(N))
U311(tt, V) → U321(isNatList(V))
U511(tt, V1, V2) → U521(isNat(V1), V2)
U421(tt, V2) → U431(isNatIList(V2))
TAKE(s(M), cons(N, IL)) → AND(isNat(N), isNatKind(N))
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
U411(tt, V1, V2) → ISNAT(V1)
U611(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → AND(isNatList(L), isNatIListKind(L))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
U411(tt, V1, V2) → U421(isNat(V1), V2)
ISNAT(length(V1)) → ISNATILISTKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNATKIND(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(IL), isNatIListKind(IL))
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
LENGTH(cons(N, L)) → U711(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U111(tt, V1) → ISNATLIST(V1)
ISNATLIST(cons(V1, V2)) → ISNATILISTKIND(V2)
U521(tt, V2) → ISNATLIST(V2)
ISNATILIST(cons(V1, V2)) → ISNATILISTKIND(V2)
LENGTH(cons(N, L)) → ISNATILISTKIND(L)
TAKE(0, IL) → U811(and(isNatIList(IL), isNatIListKind(IL)))
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(0, IL) → ISNATILISTKIND(IL)
TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
LENGTH(cons(N, L)) → ISNAT(N)
ISNATILISTKIND(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATILIST(V) → ISNATILISTKIND(V)
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)
U611(tt, V1, V2) → U621(isNat(V1), V2)
ISNATKIND(s(V1)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → AND(isNat(M), isNatKind(M))
ISNATILIST(V) → U311(isNatIListKind(V), V)
U521(tt, V2) → U531(isNatList(V2))
TAKE(0, IL) → ISNATILIST(IL)
U211(tt, V1) → ISNAT(V1)
TAKE(s(M), cons(N, IL)) → AND(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → ISNATKIND(N)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U311(tt, V) → ISNATLIST(V)
ISNAT(s(V1)) → ISNATKIND(V1)
U621(tt, V2) → U631(isNatIList(V2))
TAKE(s(M), cons(N, IL)) → ISNATILISTKIND(IL)
ISNATLIST(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → AND(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N))))
ZEROSZEROS
ISNATLIST(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(s(M), cons(N, IL)) → ISNATKIND(M)
ISNATLIST(take(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNATILIST(IL)
LENGTH(cons(N, L)) → ISNATLIST(L)
U621(tt, V2) → ISNATILIST(V2)
U111(tt, V1) → U121(isNatList(V1))
U421(tt, V2) → ISNATILIST(V2)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
TAKE(s(M), cons(N, IL)) → ISNAT(M)
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
TAKE(s(M), cons(N, IL)) → ISNAT(N)
U711(tt, L) → LENGTH(L)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
TAKE(0, IL) → AND(isNatIList(IL), isNatIListKind(IL))
U911(tt, IL, M, N) → TAKE(M, IL)
U211(tt, V1) → U221(isNat(V1))
ISNATILISTKIND(cons(V1, V2)) → ISNATILISTKIND(V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
LENGTH(cons(N, L)) → AND(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → AND(isNat(N), isNatKind(N))
U311(tt, V) → U321(isNatList(V))
U511(tt, V1, V2) → U521(isNat(V1), V2)
U421(tt, V2) → U431(isNatIList(V2))
TAKE(s(M), cons(N, IL)) → AND(isNat(N), isNatKind(N))
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
U411(tt, V1, V2) → ISNAT(V1)
U611(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 5 SCCs with 42 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
QDP
                ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → ISNATILISTKIND(V2)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATILISTKIND(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → ISNATILISTKIND(V2)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(take(V1, V2)) → ISNATILISTKIND(V2)
ISNATILISTKIND(take(V1, V2)) → ISNATKIND(V1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
QDP
                ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

U611(tt, V1, V2) → U621(isNat(V1), V2)
U511(tt, V1, V2) → ISNAT(V1)
ISNAT(s(V1)) → U211(isNatKind(V1), V1)
ISNATILIST(V) → U311(isNatIListKind(V), V)
ISNATILIST(cons(V1, V2)) → U411(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U411(tt, V1, V2) → U421(isNat(V1), V2)
U211(tt, V1) → ISNAT(V1)
U511(tt, V1, V2) → U521(isNat(V1), V2)
U621(tt, V2) → ISNATILIST(V2)
U111(tt, V1) → ISNATLIST(V1)
U521(tt, V2) → ISNATLIST(V2)
ISNATLIST(take(V1, V2)) → U611(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U421(tt, V2) → ISNATILIST(V2)
ISNATLIST(cons(V1, V2)) → U511(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U311(tt, V) → ISNATLIST(V)
ISNAT(length(V1)) → U111(isNatIListKind(V1), V1)
U411(tt, V1, V2) → ISNAT(V1)
U611(tt, V1, V2) → ISNAT(V1)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
QDP
                ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

U711(tt, L) → LENGTH(L)
LENGTH(cons(N, L)) → U711(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
QDP
                ↳ QDPSizeChangeProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TAKE(s(M), cons(N, IL)) → U911(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)
U911(tt, IL, M, N) → TAKE(M, IL)

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
QDP
                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

ZEROSZEROS

The TRS R consists of the following rules:

zeroscons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, V1, V2) → U62(isNat(V1), V2)
U62(tt, V2) → U63(isNatIList(V2))
U63(tt) → tt
U71(tt, L) → s(length(L))
U81(tt) → nil
U91(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatIListKind(take(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatList(take(V1, V2)) → U61(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U71(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
take(0, IL) → U81(and(isNatIList(IL), isNatIListKind(IL)))
take(s(M), cons(N, IL)) → U91(and(and(isNatIList(IL), isNatIListKind(IL)), and(and(isNat(M), isNatKind(M)), and(isNat(N), isNatKind(N)))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
QDP

Q DP problem:
The TRS P consists of the following rules:

ZEROSZEROS

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.